home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_200 / 207_01 / checkd.c < prev    next >
Text File  |  1980-01-01  |  20KB  |  592 lines
  1. /*  checkd.c -- 5th source file for check register program                   */
  2.  
  3. /*  copyright (c) 1986 by Jim Woolley and WoolleyWare, San Jose, CA          */
  4.  
  5. /*  vers. 1.0, 12/85 thru 5/86
  6.  */
  7.  
  8. /*  this file contains:
  9.  *      delete()
  10.  *      undo()
  11.  *      insert()
  12.  *      ctrlqork()
  13.  *      erase( c)
  14.  *      abandon()
  15.  *      save()
  16.  *      reconcile()
  17.  *      abreviations()
  18.  *      print()
  19.  *      order()
  20.  *      reorder( f)
  21.  *      datemax( md, d)
  22.  */
  23.  
  24. #include    "a:checks.h"
  25.  
  26. delete()                                /*  delete Entry[ Recno]             */
  27. {
  28.     int r;
  29.  
  30.     if ( Recno > Maxentry)
  31.         return;
  32.     if ( isibbf( Recno))
  33.     {
  34.         prompt( "Cannot delete ");
  35.         puts( BBF);
  36.         waitesc();
  37.         return;
  38.     }
  39.     r = Recno - First + HEAD;
  40.     movmem( &Entry[ Recno], &Entryundo, RECSIZ);
  41.     Modified = Ctrlyundo = TRUE;
  42.     if ( Savrecno == Recno)
  43.         Savrecno = -1;
  44.     else if ( Savrecno > Recno)
  45.         --Savrecno;
  46.     if ( Recno < Maxentry)
  47.         movmem( &Entry[ Recno + 1], &Entry[ Recno], ( Maxentry - Recno)*RECSIZ);
  48.     --Maxentry;
  49.     if ( Maxentry < 0)
  50.     {
  51.         First = 0;
  52.         Last = Maxentry = -1;
  53.     }
  54.     else First = min( First, ( Last = min( Last, Maxentry)));
  55.     dellin( r);
  56.     update( Recno);
  57.     if ( Recno > Maxentry)
  58.         Field = 0;
  59.     putcursor( Recno, Field);
  60. }
  61.  
  62. undo()                                  /*  undo delete for Entry[ Recno]    */
  63. {
  64.     if ( Ctrlyundo && insert())
  65.     {
  66.         movmem( &Entryundo, &Entry[ Recno], RECSIZ);
  67.         putrecord( Recno);
  68.         update( Recno);
  69.         putcursor( Recno, Field);
  70.     }
  71. }
  72.  
  73. insert()                                /*  insert Entry[ Recno]             */
  74. {                                       /*  return TRUE if successful        */
  75.     int i;
  76.  
  77.     if ( Maxentry == ( ENTRYSIZE - 1))
  78.     {
  79.         prompt( "Number of entries is maximum allowed");
  80.         waitesc();
  81.         return ( FALSE);
  82.     }
  83.     if ( Recno <= Maxentry)
  84.     {
  85.         i = Maxentry - Recno + 1;
  86.         movmem( &Entry[ Recno], &Entry[ Recno + 1], i*RECSIZ);
  87.         movmem( &Balance[ Recno], &Balance[ Recno + 1], i*sizeof( Balance[ 0]));
  88.     }
  89.     if ( Savrecno >= Recno)
  90.         ++Savrecno;
  91.     ++Maxentry;
  92.     newentry( Recno);                   /*  Modified will be set TRUE        */
  93.     Last = min(( Last + 1), ( First + LAST));
  94.     inslin( Recno - First + HEAD);
  95.     putcursor( Recno, Field);
  96.     return ( TRUE);
  97. }
  98.  
  99. ctrlqork( c)                            /*  process CTRLQ or CTRLK command   */
  100. char c;
  101. {
  102.     char n;
  103.     int i;
  104.  
  105.     cursorto( 0, 2);
  106.     n = putnext();
  107.     if ( c == CTRLQ)                    /*  process CTRLQ command            */
  108.     {
  109.         switch ( n)
  110.         {
  111.         case 'R':
  112.             gotop();
  113.             break;
  114.         case 'C':
  115.             gobottom();
  116.             break;
  117.         case 'D':
  118.             if ( Recno > Maxentry)
  119.                 break;
  120.             Character = PAYEESIZE;      /*  putcursor() will readjust        */
  121.             putcursor( Recno, ( Field = MAXFIELD - 1));
  122.             break;
  123.         case 'S':  case 'H':
  124.             Character = 0;
  125.             putcursor( Recno, ( Field = 0));
  126.             break;
  127.         case 'E':
  128.             putcursor(( Recno = First), Field);
  129.             break;
  130.         case 'X':
  131.             Recno = min(( Maxentry + 1), ( First + ( LAST - 1)));
  132.             if ( Recno > Maxentry)
  133.                 Field = 0;
  134.             putcursor( Recno, Field);
  135.             break;
  136.         case 'Y':  case DEL:  case ( CTRL_ + CTRLTOA):
  137.             if ( Field == PAYFIELD)
  138.             {
  139.                 strcpy( Savpayee, Entry[ Recno].payee);
  140.                 Savrecno = Recno;
  141.                 putcursor( Recno, Field);
  142.                 erase( n);
  143.             }
  144.             break;
  145.         case 'W':  case 'Z':
  146.             goupdown( n);
  147.             break;
  148.         default:
  149.             putchar( BEL);
  150.             break;
  151.         }
  152.     }
  153.     else                                /*  process CTRLK command            */
  154.     {
  155.         switch ( n)
  156.         {
  157.         case 'O':
  158.             order( 0);
  159.             break;
  160.         case 'D':  case 'X':
  161.             done();                     /*  never returns                    */
  162.             break;
  163.         case 'S':
  164.             save();
  165.             break;
  166.         case 'Q':
  167.             abandon();                  /*  may not return                   */
  168.             break;
  169.         case 'R':
  170.             reconcile();
  171.             break;
  172.         case 'A':
  173.             abreviations();
  174.             break;
  175.         case 'P':
  176.             print();
  177.             break;
  178.         default:
  179.             putchar( BEL);
  180.             break;
  181.         }
  182.     }
  183. }
  184.  
  185. erase( c)                               /*  erase payee left or right        */
  186. char c;
  187. {
  188.     char *p, *q;
  189.     int count;
  190.  
  191.     q = Entry[ Recno].payee;
  192.     p = q + Character;
  193.     if ( c == 'Y')
  194.     {
  195.         count = strlen( p);
  196.         *p = '\0';
  197.     }
  198.     else if ( !Character)
  199.         return;
  200.     else
  201.     {
  202.         strcpy( q, p);
  203.         count = Character;
  204.         Character = 0;
  205.         putcursor( Recno, Field);
  206.         puts( q);
  207.     }
  208.     while ( count--)
  209.         putchar( PAYEEFILL);
  210.     Modified = TRUE;
  211. }
  212.  
  213. abandon()                               /*  abandon without resave           */
  214. {
  215.     if ( Modified)
  216.     {
  217.         prompt( "Abandon without saving changes (Y/N)? ");
  218.         if ( getyesno( NO))
  219.             aexit();
  220.     }
  221.     else
  222.     {
  223.         prompt( "Abandoning unchanged file");
  224.         aexit();
  225.     }
  226. }
  227.  
  228. save()                                  /*  save entries and continue        */
  229. {
  230.     prompt( "");                        /*  clear prompt line                */
  231.     if ( savedat())                     /*  if error                         */
  232.         return;
  233.     waitesc();                          /*  else, wait for recognition       */
  234.     Modified = FALSE;
  235. }
  236.  
  237. reconcile()                             /*  display summary by category      */
  238. {
  239.     char c, *spaces, *sh, *ss, scroll, nbr[ DEL];
  240.     int i, j, count, lines, firstline, lastline, maxline;
  241.     struct
  242.         {
  243.         struct calendar maxdate;
  244.         char sumcategory;
  245.         struct money beginbal, clrcheck, clrdeposit, allcheck, alldeposit;
  246.         } sum, *a, *start;
  247.     struct record *e;
  248.     struct money *m, clrendbal, allendbal;
  249.  
  250.     spaces = "           ";
  251.     sh =
  252. "--------  --------  --------  --------  --------  --------  --------";
  253.     ss = "-------- - ";
  254.     prompt( "");
  255.     setmem( nbr, DEL, 0);               /*  initialize                       */
  256.     for ( j = 0; j <= Maxentry; ++j)    /*  count number in each category    */
  257.         ++nbr[ Entry[ j].category & 0x7f];
  258.     lines = 0;
  259.     for ( i = ' '; i < DEL; ++i)        /*  count separate categories, then  */
  260.         if ( nbr[ i])                   /*      allocate space for each      */
  261.             ++lines;
  262.     if ( !lines)
  263.         return;
  264.     if ( !( a = start = alloc( lines*sizeof( *a))))
  265.     {
  266.         prompt( "Insufficient memory to reconcile all categories");
  267.         waitesc();
  268.         return;
  269.     }
  270.     recheading( ss, sh);
  271.     setmem( &sum, sizeof( sum), 0);      /*  initialize                       */
  272.     setmem( a, ( lines*sizeof( *a)), 0);
  273.     for ( i = ' '; i < DEL; ++i)        /*  summarize each category          */
  274.     {
  275.         if ( !nbr[ i])                  /*  if category does not exist       */
  276.             continue;                   /*      next category                */
  277.         a->sumcategory = i;
  278.         count = 0;
  279.         for ( j = 0; j <= Maxentry; ++j)
  280.         {                               /*  loop thru entries                */
  281.             e = &Entry[ j];
  282.             if ((( c = e->category) & 0x7f) != i)
  283.                 continue;               /*  next entry                       */
  284.             datemax( &( a->maxdate), &( e->date));
  285.             m = &( e->amount);
  286.             if ( c & 0x80)              /*  if a BBF entry